home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_gtk+.idb / usr / freeware / include / gtk / gtkstyle.h.z / gtkstyle.h
Encoding:
C/C++ Source or Header  |  1999-07-16  |  20.4 KB  |  781 lines
  1. /* GTK - The GIMP Toolkit
  2.  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Library General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  12.  * Library General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Library General Public
  15.  * License along with this library; if not, write to the
  16.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17.  * Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. /*
  21.  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  22.  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23.  * files for a list of changes.  These files are distributed with
  24.  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  25.  */
  26.  
  27. #ifndef __GTK_STYLE_H__
  28. #define __GTK_STYLE_H__
  29.  
  30.  
  31. #include <gdk/gdk.h>
  32. #include <gtk/gtkenums.h>
  33.  
  34. #ifdef __cplusplus
  35. extern "C" {
  36. #endif /* __cplusplus */
  37.  
  38. typedef struct _GtkStyle       GtkStyle;
  39. typedef struct _GtkStyleClass  GtkStyleClass;
  40.  
  41. /* Some forward declarations needed to rationalize the header
  42.  * files.
  43.  */
  44. typedef struct _GtkThemeEngine GtkThemeEngine;
  45. typedef struct _GtkRcStyle     GtkRcStyle;
  46.  
  47.  
  48. /* We make this forward declaration here, since we pass
  49.  * GtkWidgt's to the draw functions.
  50.  */
  51. typedef struct _GtkWidget      GtkWidget;
  52.  
  53. /* This is used for having dynamic style changing stuff
  54.  * fg, bg, light, dark, mid, text, base
  55.  */
  56. #define GTK_STYLE_NUM_STYLECOLORS()    (7 * 5)
  57.  
  58. #define GTK_STYLE_ATTACHED(style)    (((GtkStyle*) (style))->attach_count > 0)
  59.  
  60. struct _GtkStyle
  61. {
  62.   GtkStyleClass *klass;
  63.  
  64.   GdkColor fg[5];
  65.   GdkColor bg[5];
  66.   GdkColor light[5];
  67.   GdkColor dark[5];
  68.   GdkColor mid[5];
  69.   GdkColor text[5];
  70.   GdkColor base[5];
  71.   
  72.   GdkColor black;
  73.   GdkColor white;
  74.   GdkFont *font;
  75.   
  76.   GdkGC *fg_gc[5];
  77.   GdkGC *bg_gc[5];
  78.   GdkGC *light_gc[5];
  79.   GdkGC *dark_gc[5];
  80.   GdkGC *mid_gc[5];
  81.   GdkGC *text_gc[5];
  82.   GdkGC *base_gc[5];
  83.   GdkGC *black_gc;
  84.   GdkGC *white_gc;
  85.   
  86.   GdkPixmap *bg_pixmap[5];
  87.   
  88.   /* private */
  89.   
  90.   gint ref_count;
  91.   gint attach_count;
  92.   
  93.   gint depth;
  94.   GdkColormap *colormap;
  95.   
  96.   GtkThemeEngine *engine;
  97.   
  98.   gpointer      engine_data;
  99.   
  100.   GtkRcStyle     *rc_style;    /* the Rc style from which this style
  101.                  * was created
  102.                  */
  103.   GSList     *styles;
  104. };
  105.  
  106. struct _GtkStyleClass
  107. {
  108.   gint xthickness;
  109.   gint ythickness;
  110.   
  111.   void (*draw_hline)        (GtkStyle        *style,
  112.                  GdkWindow        *window,
  113.                  GtkStateType         state_type,
  114.                  GdkRectangle        *area,
  115.                  GtkWidget        *widget,
  116.                  gchar            *detail,
  117.                  gint             x1,
  118.                  gint             x2,
  119.                  gint             y);
  120.   void (*draw_vline)        (GtkStyle        *style,
  121.                  GdkWindow        *window,
  122.                  GtkStateType         state_type,
  123.                  GdkRectangle        *area,
  124.                  GtkWidget        *widget,
  125.                  gchar            *detail,
  126.                  gint             y1,
  127.                  gint             y2,
  128.                  gint             x);
  129.   void (*draw_shadow)        (GtkStyle        *style,
  130.                  GdkWindow        *window,
  131.                  GtkStateType         state_type,
  132.                  GtkShadowType         shadow_type,
  133.                  GdkRectangle        *area,
  134.                  GtkWidget        *widget,
  135.                  gchar            *detail,
  136.                  gint             x,
  137.                  gint             y,
  138.                  gint             width,
  139.                  gint             height);
  140.   void (*draw_polygon)        (GtkStyle        *style,
  141.                  GdkWindow        *window,
  142.                  GtkStateType         state_type,
  143.                  GtkShadowType         shadow_type,
  144.                  GdkRectangle        *area,
  145.                  GtkWidget        *widget,
  146.                  gchar            *detail,
  147.                  GdkPoint        *point,
  148.                  gint             npoints,
  149.                  gboolean         fill);
  150.   void (*draw_arrow)        (GtkStyle        *style,
  151.                  GdkWindow        *window,
  152.                  GtkStateType         state_type,
  153.                  GtkShadowType         shadow_type,
  154.                  GdkRectangle        *area,
  155.                  GtkWidget        *widget,
  156.                  gchar            *detail,
  157.                  GtkArrowType         arrow_type,
  158.                  gboolean         fill,
  159.                  gint             x,
  160.                  gint             y,
  161.                  gint             width,
  162.                  gint             height);
  163.   void (*draw_diamond)        (GtkStyle        *style,
  164.                  GdkWindow        *window,
  165.                  GtkStateType         state_type,
  166.                  GtkShadowType         shadow_type,
  167.                  GdkRectangle        *area,
  168.                  GtkWidget        *widget,
  169.                  gchar            *detail,
  170.                  gint             x,
  171.                  gint             y,
  172.                  gint             width,
  173.                  gint             height);
  174.   void (*draw_oval)        (GtkStyle        *style,
  175.                  GdkWindow        *window,
  176.                  GtkStateType         state_type,
  177.                  GtkShadowType         shadow_type,
  178.                  GdkRectangle        *area,
  179.                  GtkWidget        *widget,
  180.                  gchar            *detail,
  181.                  gint             x,
  182.                  gint             y,
  183.                  gint             width,
  184.                  gint             height);
  185.   void (*draw_string)        (GtkStyle        *style,
  186.                  GdkWindow        *window,
  187.                  GtkStateType         state_type,
  188.                  GdkRectangle        *area,
  189.                  GtkWidget        *widget,
  190.                  gchar            *detail,
  191.                  gint             x,
  192.                  gint             y,
  193.                  const gchar        *string);
  194.   void (*draw_box)        (GtkStyle        *style,
  195.                  GdkWindow        *window,
  196.                  GtkStateType         state_type,
  197.                  GtkShadowType         shadow_type,
  198.                  GdkRectangle        *area,
  199.                  GtkWidget        *widget,
  200.                  gchar            *detail,
  201.                  gint             x,
  202.                  gint             y,
  203.                  gint             width,
  204.                  gint             height);
  205.   void (*draw_flat_box)        (GtkStyle        *style,
  206.                  GdkWindow        *window,
  207.                  GtkStateType         state_type,
  208.                  GtkShadowType         shadow_type,
  209.                  GdkRectangle        *area,
  210.                  GtkWidget        *widget,
  211.                  gchar            *detail,
  212.                  gint             x,
  213.                  gint             y,
  214.                  gint             width,
  215.                  gint             height);
  216.   void (*draw_check)        (GtkStyle        *style,
  217.                  GdkWindow        *window,
  218.                  GtkStateType         state_type,
  219.                  GtkShadowType         shadow_type,
  220.                  GdkRectangle        *area,
  221.                  GtkWidget        *widget,
  222.                  gchar            *detail,
  223.                  gint             x,
  224.                  gint             y,
  225.                  gint             width,
  226.                  gint             height);
  227.   void (*draw_option)        (GtkStyle        *style,
  228.                  GdkWindow        *window,
  229.                  GtkStateType         state_type,
  230.                  GtkShadowType         shadow_type,
  231.                  GdkRectangle        *area,
  232.                  GtkWidget        *widget,
  233.                  gchar            *detail,
  234.                  gint             x,
  235.                  gint             y,
  236.                  gint             width,
  237.                  gint             height);
  238.   void (*draw_cross)        (GtkStyle        *style,
  239.                  GdkWindow        *window,
  240.                  GtkStateType         state_type,
  241.                  GtkShadowType         shadow_type,
  242.                  GdkRectangle        *area,
  243.                  GtkWidget        *widget,
  244.                  gchar            *detail,
  245.                  gint             x,
  246.                  gint             y,
  247.                  gint             width,
  248.                  gint             height);
  249.   void (*draw_ramp)        (GtkStyle        *style,
  250.                  GdkWindow        *window,
  251.                  GtkStateType         state_type,
  252.                  GtkShadowType         shadow_type,
  253.                  GdkRectangle        *area,
  254.                  GtkWidget        *widget,
  255.                  gchar            *detail,
  256.                  GtkArrowType         arrow_type,
  257.                  gint             x,
  258.                  gint             y,
  259.                  gint             width,
  260.                  gint             height);
  261.   void (*draw_tab)        (GtkStyle        *style,
  262.                  GdkWindow        *window,
  263.                  GtkStateType         state_type,
  264.                  GtkShadowType         shadow_type,
  265.                  GdkRectangle        *area,
  266.                  GtkWidget        *widget,
  267.                  gchar            *detail,
  268.                  gint             x,
  269.                  gint             y,
  270.                  gint             width,
  271.                  gint             height); 
  272.   void (*draw_shadow_gap)    (GtkStyle        *style,
  273.                  GdkWindow        *window,
  274.                  GtkStateType         state_type,
  275.                  GtkShadowType         shadow_type,
  276.                  GdkRectangle        *area,
  277.                  GtkWidget        *widget,
  278.                  gchar            *detail,
  279.                  gint             x,
  280.                  gint             y,
  281.                  gint             width,
  282.                  gint             height,
  283.                  GtkPositionType     gap_side,
  284.                  gint             gap_x,
  285.                  gint             gap_width);
  286.   void (*draw_box_gap)        (GtkStyle        *style,
  287.                  GdkWindow        *window,
  288.                  GtkStateType         state_type,
  289.                  GtkShadowType         shadow_type,
  290.                  GdkRectangle        *area,
  291.                  GtkWidget        *widget,
  292.                  gchar            *detail,
  293.                  gint             x,
  294.                  gint             y,
  295.                  gint             width,
  296.                  gint             height,
  297.                  GtkPositionType     gap_side,
  298.                  gint             gap_x,
  299.                  gint             gap_width);
  300.   void (*draw_extension)    (GtkStyle        *style,
  301.                  GdkWindow        *window,
  302.                  GtkStateType         state_type,
  303.                  GtkShadowType         shadow_type,
  304.                  GdkRectangle        *area,
  305.                  GtkWidget        *widget,
  306.                  gchar            *detail,
  307.                  gint             x,
  308.                  gint             y,
  309.                  gint             width,
  310.                  gint             height,
  311.                  GtkPositionType     gap_side);
  312.   void (*draw_focus)        (GtkStyle        *style,
  313.                  GdkWindow        *window,
  314.                  GdkRectangle        *area,
  315.                  GtkWidget        *widget,
  316.                  gchar            *detail,
  317.                  gint             x,
  318.                  gint             y,
  319.                  gint             width,
  320.                  gint             height);
  321.   void (*draw_slider)        (GtkStyle        *style,
  322.                  GdkWindow        *window,
  323.                  GtkStateType         state_type,
  324.                  GtkShadowType         shadow_type,
  325.                  GdkRectangle        *area,
  326.                  GtkWidget        *widget,
  327.                  gchar            *detail,
  328.                  gint             x,
  329.                  gint             y,
  330.                  gint             width,
  331.                  gint             height,
  332.                  GtkOrientation         orientation);
  333.   void (*draw_handle)        (GtkStyle        *style,
  334.                  GdkWindow        *window,
  335.                  GtkStateType         state_type,
  336.                  GtkShadowType         shadow_type,
  337.                  GdkRectangle        *area,
  338.                  GtkWidget        *widget,
  339.                  gchar            *detail,
  340.                  gint             x,
  341.                  gint             y,
  342.                  gint             width,
  343.                  gint             height,
  344.                  GtkOrientation         orientation);
  345. };
  346.  
  347. GtkStyle* gtk_style_new                 (void);
  348. GtkStyle* gtk_style_copy             (GtkStyle        *style);
  349. GtkStyle* gtk_style_attach             (GtkStyle        *style,
  350.                           GdkWindow        *window);
  351. void      gtk_style_detach             (GtkStyle       *style);
  352. GtkStyle* gtk_style_ref                 (GtkStyle       *style);
  353. void      gtk_style_unref             (GtkStyle       *style);
  354. void      gtk_style_set_background         (GtkStyle       *style,
  355.                           GdkWindow       *window,
  356.                           GtkStateType  state_type);
  357. void      gtk_style_apply_default_background (GtkStyle       *style,
  358.                           GdkWindow       *window,
  359.                           gboolean        set_bg,
  360.                           GtkStateType  state_type, 
  361.                           GdkRectangle *area, 
  362.                           gint        x, 
  363.                           gint        y, 
  364.                           gint        width, 
  365.                           gint        height);
  366.  
  367. void gtk_draw_hline   (GtkStyle         *style,
  368.                GdkWindow     *window,
  369.                GtkStateType   state_type,
  370.                gint          x1,
  371.                gint          x2,
  372.                gint          y);
  373. void gtk_draw_vline   (GtkStyle         *style,
  374.                GdkWindow     *window,
  375.                GtkStateType   state_type,
  376.                gint          y1,
  377.                gint          y2,
  378.                gint          x);
  379. void gtk_draw_shadow  (GtkStyle         *style,
  380.                GdkWindow     *window,
  381.                GtkStateType   state_type,
  382.                GtkShadowType  shadow_type,
  383.                gint          x,
  384.                gint          y,
  385.                gint          width,
  386.                gint          height);
  387. void gtk_draw_polygon (GtkStyle         *style,
  388.                GdkWindow     *window,
  389.                GtkStateType   state_type,
  390.                GtkShadowType  shadow_type,
  391.                GdkPoint         *points,
  392.                gint          npoints,
  393.                gboolean          fill);
  394. void gtk_draw_arrow   (GtkStyle         *style,
  395.                GdkWindow     *window,
  396.                GtkStateType   state_type,
  397.                GtkShadowType  shadow_type,
  398.                GtkArrowType   arrow_type,
  399.                gboolean          fill,
  400.                gint          x,
  401.                gint          y,
  402.                gint          width,
  403.                gint          height);
  404. void gtk_draw_diamond (GtkStyle         *style,
  405.                GdkWindow     *window,
  406.                GtkStateType   state_type,
  407.                GtkShadowType  shadow_type,
  408.                gint          x,
  409.                gint          y,
  410.                gint          width,
  411.                gint          height);
  412. void gtk_draw_oval    (GtkStyle         *style,
  413.                GdkWindow     *window,
  414.                GtkStateType   state_type,
  415.                GtkShadowType  shadow_type,
  416.                gint          x,
  417.                gint          y,
  418.                gint          width,
  419.                gint          height);
  420. void gtk_draw_string  (GtkStyle         *style,
  421.                GdkWindow     *window,
  422.                GtkStateType   state_type,
  423.                gint          x,
  424.                gint          y,
  425.                const gchar   *string);
  426. void gtk_draw_box     (GtkStyle         *style,
  427.                GdkWindow     *window,
  428.                GtkStateType   state_type,
  429.                GtkShadowType  shadow_type,
  430.                gint          x,
  431.                gint          y,
  432.                gint          width,
  433.                gint          height);
  434. void gtk_draw_flat_box (GtkStyle      *style,
  435.             GdkWindow     *window,
  436.             GtkStateType   state_type,
  437.             GtkShadowType  shadow_type,
  438.             gint           x,
  439.             gint           y,
  440.             gint           width,
  441.             gint           height);
  442. void gtk_draw_check   (GtkStyle         *style,
  443.                GdkWindow     *window,
  444.                GtkStateType   state_type,
  445.                GtkShadowType  shadow_type,
  446.                gint          x,
  447.                gint          y,
  448.                gint          width,
  449.                gint          height);
  450. void gtk_draw_option  (GtkStyle         *style,
  451.                GdkWindow     *window,
  452.                GtkStateType   state_type,
  453.                GtkShadowType  shadow_type,
  454.                gint          x,
  455.                gint          y,
  456.                gint          width,
  457.                gint          height);
  458. void gtk_draw_cross   (GtkStyle         *style,
  459.                GdkWindow     *window,
  460.                GtkStateType   state_type,
  461.                GtkShadowType  shadow_type,
  462.                gint          x,
  463.                gint          y,
  464.                gint          width,
  465.                gint          height);
  466. void gtk_draw_ramp    (GtkStyle         *style,
  467.                GdkWindow     *window,
  468.                GtkStateType   state_type,
  469.                GtkShadowType  shadow_type,
  470.                GtkArrowType   arrow_type,
  471.                gint          x,
  472.                gint          y,
  473.                gint          width,
  474.                gint          height);
  475. void gtk_draw_tab     (GtkStyle         *style,
  476.                GdkWindow     *window,
  477.                GtkStateType   state_type,
  478.                GtkShadowType  shadow_type,
  479.                gint          x,
  480.                gint          y,
  481.                gint          width,
  482.                gint          height);
  483. void gtk_draw_shadow_gap (GtkStyle     *style,
  484.               GdkWindow     *window,
  485.               GtkStateType      state_type,
  486.               GtkShadowType      shadow_type,
  487.               gint          x,
  488.               gint          y,
  489.               gint          width,
  490.               gint          height,
  491.               GtkPositionType gap_side,
  492.               gint          gap_x,
  493.               gint          gap_width);
  494. void gtk_draw_box_gap (GtkStyle          *style,
  495.                GdkWindow      *window,
  496.                GtkStateType    state_type,
  497.                GtkShadowType   shadow_type,
  498.                gint           x,
  499.                gint           y,
  500.                gint           width,
  501.                gint           height,
  502.                GtkPositionType gap_side,
  503.                gint           gap_x,
  504.                gint           gap_width);
  505. void gtk_draw_extension (GtkStyle    *style,
  506.              GdkWindow    *window,
  507.              GtkStateType     state_type,
  508.              GtkShadowType     shadow_type,
  509.              gint         x,
  510.              gint         y,
  511.              gint         width,
  512.              gint         height,
  513.              GtkPositionType gap_side);
  514. void gtk_draw_focus   (GtkStyle         *style,
  515.                GdkWindow     *window,
  516.                gint          x,
  517.                gint          y,
  518.                gint          width,
  519.                gint          height);
  520. void gtk_draw_slider  (GtkStyle         *style,
  521.                GdkWindow     *window,
  522.                GtkStateType   state_type,
  523.                GtkShadowType  shadow_type,
  524.                gint          x,
  525.                gint          y,
  526.                gint          width,
  527.                gint          height,
  528.                GtkOrientation orientation);
  529. void gtk_draw_handle  (GtkStyle         *style,
  530.                GdkWindow     *window,
  531.                GtkStateType   state_type,
  532.                GtkShadowType  shadow_type,
  533.                gint          x,
  534.                gint          y,
  535.                gint          width,
  536.                gint          height,
  537.                GtkOrientation orientation);
  538.  
  539. void gtk_paint_hline   (GtkStyle      *style,
  540.             GdkWindow     *window,
  541.             GtkStateType   state_type,
  542.             GdkRectangle  *area,
  543.             GtkWidget     *widget,
  544.             gchar          *detail,
  545.             gint           x1,
  546.             gint           x2,
  547.             gint           y);
  548. void gtk_paint_vline   (GtkStyle      *style,
  549.             GdkWindow     *window,
  550.             GtkStateType   state_type,
  551.             GdkRectangle  *area,
  552.             GtkWidget     *widget,
  553.             gchar          *detail,
  554.             gint           y1,
  555.             gint           y2,
  556.             gint           x);
  557. void gtk_paint_shadow  (GtkStyle     *style,
  558.             GdkWindow    *window,
  559.             GtkStateType  state_type,
  560.             GtkShadowType shadow_type,
  561.             GdkRectangle  *area,
  562.             GtkWidget     *widget,
  563.             gchar          *detail,
  564.             gint           x,
  565.             gint           y,
  566.             gint           width,
  567.             gint           height);
  568. void gtk_paint_polygon (GtkStyle      *style,
  569.             GdkWindow     *window,
  570.             GtkStateType   state_type,
  571.             GtkShadowType  shadow_type,
  572.             GdkRectangle  *area,
  573.             GtkWidget     *widget,
  574.             gchar          *detail,
  575.             GdkPoint      *points,
  576.             gint           npoints,
  577.             gboolean       fill);
  578. void gtk_paint_arrow   (GtkStyle      *style,
  579.             GdkWindow     *window,
  580.             GtkStateType   state_type,
  581.             GtkShadowType  shadow_type,
  582.             GdkRectangle  *area,
  583.             GtkWidget     *widget,
  584.             gchar          *detail,
  585.             GtkArrowType   arrow_type,
  586.             gboolean       fill,
  587.             gint           x,
  588.             gint           y,
  589.             gint           width,
  590.             gint           height);
  591. void gtk_paint_diamond (GtkStyle      *style,
  592.             GdkWindow     *window,
  593.             GtkStateType   state_type,
  594.             GtkShadowType  shadow_type,
  595.             GdkRectangle  *area,
  596.             GtkWidget     *widget,
  597.             gchar          *detail,
  598.             gint           x,
  599.             gint           y,
  600.             gint           width,
  601.             gint           height);
  602. void gtk_paint_oval    (GtkStyle      *style,
  603.             GdkWindow     *window,
  604.             GtkStateType   state_type,
  605.             GtkShadowType  shadow_type,
  606.             GdkRectangle  *area,
  607.             GtkWidget     *widget,
  608.             gchar          *detail,
  609.             gint           x,
  610.             gint           y,
  611.             gint           width,
  612.             gint           height);
  613. void gtk_paint_string  (GtkStyle      *style,
  614.             GdkWindow     *window,
  615.             GtkStateType   state_type,
  616.             GdkRectangle  *area,
  617.             GtkWidget     *widget,
  618.             gchar          *detail,
  619.             gint           x,
  620.             gint           y,
  621.             const gchar   *string);
  622. void gtk_paint_box     (GtkStyle      *style,
  623.             GdkWindow     *window,
  624.             GtkStateType   state_type,
  625.             GtkShadowType  shadow_type,
  626.             GdkRectangle  *area,
  627.             GtkWidget     *widget,
  628.             gchar          *detail,
  629.             gint           x,
  630.             gint           y,
  631.             gint           width,
  632.             gint           height);
  633. void gtk_paint_flat_box (GtkStyle      *style,
  634.              GdkWindow     *window,
  635.              GtkStateType    state_type,
  636.              GtkShadowType    shadow_type,
  637.              GdkRectangle  *area,
  638.              GtkWidget     *widget,
  639.              gchar           *detail,
  640.              gint        x,
  641.              gint        y,
  642.              gint        width,
  643.              gint        height);
  644. void gtk_paint_check   (GtkStyle      *style,
  645.             GdkWindow     *window,
  646.             GtkStateType   state_type,
  647.             GtkShadowType  shadow_type,
  648.             GdkRectangle  *area,
  649.             GtkWidget     *widget,
  650.             gchar          *detail,
  651.             gint           x,
  652.             gint           y,
  653.             gint           width,
  654.             gint           height);
  655. void gtk_paint_option  (GtkStyle      *style,
  656.             GdkWindow     *window,
  657.             GtkStateType   state_type,
  658.             GtkShadowType  shadow_type,
  659.             GdkRectangle  *area,
  660.             GtkWidget     *widget,
  661.             gchar          *detail,
  662.             gint           x,
  663.             gint           y,
  664.             gint           width,
  665.             gint           height);
  666. void gtk_paint_cross   (GtkStyle      *style,
  667.             GdkWindow     *window,
  668.             GtkStateType   state_type,
  669.             GtkShadowType  shadow_type,
  670.             GdkRectangle  *area,
  671.             GtkWidget     *widget,
  672.             gchar          *detail,
  673.             gint           x,
  674.             gint           y,
  675.             gint           width,
  676.             gint           height);
  677. void gtk_paint_ramp    (GtkStyle      *style,
  678.             GdkWindow     *window,
  679.             GtkStateType   state_type,
  680.             GtkShadowType  shadow_type,
  681.             GdkRectangle  *area,
  682.             GtkWidget     *widget,
  683.             gchar          *detail,
  684.             GtkArrowType   arrow_type,
  685.             gint           x,
  686.             gint           y,
  687.             gint           width,
  688.             gint           height);
  689. void gtk_paint_tab     (GtkStyle      *style,
  690.             GdkWindow     *window,
  691.             GtkStateType   state_type,
  692.             GtkShadowType  shadow_type,
  693.             GdkRectangle  *area,
  694.             GtkWidget     *widget,
  695.             gchar          *detail,
  696.             gint           x,
  697.             gint           y,
  698.             gint           width,
  699.             gint           height);
  700. void gtk_paint_shadow_gap (GtkStyle      *style,
  701.                GdkWindow      *window,
  702.                GtkStateType       state_type,
  703.                GtkShadowType   shadow_type,
  704.                GdkRectangle      *area,
  705.                GtkWidget      *widget,
  706.                gchar      *detail,
  707.                gint           x,
  708.                gint           y,
  709.                gint           width,
  710.                gint           height,
  711.                GtkPositionType gap_side,
  712.                gint           gap_x,
  713.                gint           gap_width);
  714. void gtk_paint_box_gap (GtkStyle       *style,
  715.             GdkWindow      *window,
  716.             GtkStateType    state_type,
  717.             GtkShadowType    shadow_type,
  718.             GdkRectangle   *area,
  719.             GtkWidget      *widget,
  720.             gchar           *detail,
  721.             gint        x,
  722.             gint        y,
  723.             gint        width,
  724.             gint        height,
  725.             GtkPositionType gap_side,
  726.             gint        gap_x,
  727.             gint        gap_width);
  728. void gtk_paint_extension (GtkStyle     *style,
  729.               GdkWindow     *window,
  730.               GtkStateType      state_type,
  731.               GtkShadowType      shadow_type,
  732.               GdkRectangle     *area,
  733.               GtkWidget     *widget,
  734.               gchar         *detail,
  735.               gint          x,
  736.               gint          y,
  737.               gint          width,
  738.               gint          height,
  739.               GtkPositionType gap_side);
  740. void gtk_paint_focus   (GtkStyle      *style,
  741.             GdkWindow     *window,
  742.             GdkRectangle  *area,
  743.             GtkWidget     *widget,
  744.             gchar          *detail,
  745.             gint           x,
  746.             gint           y,
  747.             gint           width,
  748.             gint           height);
  749. void gtk_paint_slider  (GtkStyle      *style,
  750.             GdkWindow     *window,
  751.             GtkStateType   state_type,
  752.             GtkShadowType  shadow_type,
  753.             GdkRectangle  *area,
  754.             GtkWidget     *widget,
  755.             gchar          *detail,
  756.             gint           x,
  757.             gint           y,
  758.             gint           width,
  759.             gint           height,
  760.             GtkOrientation orientation);
  761. void gtk_paint_handle  (GtkStyle      *style,
  762.             GdkWindow     *window,
  763.             GtkStateType   state_type,
  764.             GtkShadowType  shadow_type,
  765.             GdkRectangle  *area,
  766.             GtkWidget     *widget,
  767.             gchar          *detail,
  768.             gint           x,
  769.             gint           y,
  770.             gint           width,
  771.             gint           height,
  772.             GtkOrientation orientation);
  773.  
  774.  
  775. #ifdef __cplusplus
  776. }
  777. #endif /* __cplusplus */
  778.  
  779.  
  780. #endif /* __GTK_STYLE_H__ */
  781.